Node.js 学习笔记

// math.js

// 方式1：exports 导出
exports.add = function(a, b) {  // exports是module.exports的引用,通过点语法添加属性
    return a + b;  // 导出的函数可以在其他模块中通过require引入使用
};

exports.subtract = function(a, b) {  // 可以多次使用exports添加多个导出
    return a - b;
};

// 方式2：module.exports 导出（推荐）
module.exports = {  // 直接给module.exports赋值一个对象
    add: (a, b) => a + b,  // 使用ES6箭头函数简写
    subtract: (a, b) => a - b,  // 所有属性都会被导出
    multiply: (a, b) => a * b  // 这种方式更清晰,一次性导出所有接口
};

// 导出单个函数
module.exports = function(a, b) {  // 直接导出一个函数,而不是对象
    return a + b;  // 导入时得到的就是这个函数本身
};

// 导出类
module.exports = class Calculator {  // 导出一个类定义
    add(a, b) {  // 类的方法
        return a + b;  // 导入后可以new这个类来创建实例
    }
};

// app.js

// 导入内置模块
const fs = require('fs');  // require返回模块导出的内容,内置模块无需路径
const path = require('path');  // Node.js会自动从核心模块中查找

// 导入自定义模块
const math = require('./math');  // 相对路径,./表示当前目录,require会自动添加.js扩展名
const utils = require('./utils/index');  // 可以省略 index.js,Node.js会自动查找index.js

// 导入第三方模块
const express = require('express');  // 从node_modules目录查找,无需路径前缀
const axios = require('axios');  // 第三方模块需要先通过npm install安装

// 使用模块
console.log(math.add(1, 2));  // 3,调用导入模块的方法

// exports 是 module.exports 的引用
console.log(exports === module.exports);  // true

// exports 只能通过点语法添加属性
exports.name = '张三';  // ✓

// 不能直接给 exports 赋值（会断开引用）
exports = { name: '张三' };  // ✗ 无效

// module.exports 可以直接赋值
module.exports = { name: '张三' };  // ✓

// 最终导出的是 module.exports

// math.mjs 或在 package.json 中设置 "type": "module"

// 具名导出
export const add = (a, b) => a + b;
export const subtract = (a, b) => a - b;

// 批量导出
const multiply = (a, b) => a * b;
const divide = (a, b) => a / b;
export { multiply, divide };

// 默认导出
export default class Calculator {
    add(a, b) {
        return a + b;
    }
}

// 导入具名导出
import { add, subtract } from './math.mjs';

// 导入全部
import * as math from './math.mjs';

// 导入默认导出
import Calculator from './math.mjs';

// 混合导入
import Calculator, { add, subtract } from './math.mjs';

// Node.js 模块加载优先级：
// 1. 缓存的模块
// 2. 内置模块
// 3. 文件模块（相对/绝对路径）
// 4. 第三方模块（node_modules）

// 模块会被缓存
const math1 = require('./math');
const math2 = require('./math');
console.log(math1 === math2);  // true（同一个对象）

// 查看模块缓存
console.log(require.cache);

// 清除缓存
delete require.cache[require.resolve('./math')];

const path = require('path');

// 路径拼接（推荐使用，自动处理分隔符）
path.join('/foo', 'bar', 'baz');          // '/foo/bar/baz'
path.join('/foo', './bar', 'baz');        // '/foo/bar/baz'
path.join('/foo', '../bar', 'baz');       // '/bar/baz'

// 路径解析（解析为绝对路径）
path.resolve('foo', 'bar');               // '/当前目录/foo/bar'
path.resolve('/foo', 'bar');              // '/foo/bar'
path.resolve('/foo', '/bar');             // '/bar'（后面的绝对路径会覆盖）

// 获取文件名
path.basename('/foo/bar/file.txt');       // 'file.txt'
path.basename('/foo/bar/file.txt', '.txt');  // 'file'

// 获取目录名
path.dirname('/foo/bar/baz.txt');         // '/foo/bar'

// 获取扩展名
path.extname('index.html');               // '.html'
path.extname('index.');                   // '.'
path.extname('index');                    // ''

// 格式化路径
path.format({
    dir: '/home/user',
    base: 'file.txt'
});  // '/home/user/file.txt'

// 解析路径
path.parse('/home/user/file.txt');
// {
//     root: '/',
//     dir: '/home/user',
//     base: 'file.txt',
//     ext: '.txt',
//     name: 'file'
// }

// 路径分隔符
console.log(path.sep);        // Windows: '\', POSIX: '/'
console.log(path.delimiter);  // Windows: ';', POSIX: ':'

// 常用全局变量
console.log(__filename);  // 当前文件的绝对路径
console.log(__dirname);   // 当前文件所在目录的绝对路径

const fs = require('fs');

// 异步读取（回调方式）
fs.readFile('./file.txt', 'utf8', (err, data) => {
    if (err) {
        console.error('读取失败:', err);
        return;
    }
    console.log(data);
});

// 同步读取
try {
    const data = fs.readFileSync('./file.txt', 'utf8');
    console.log(data);
} catch (err) {
    console.error('读取失败:', err);
}

// Promise 方式（Node.js 10+）
const fsPromises = require('fs').promises;
// 等价写法（推荐）：直接引入 fs/promises 子模块
// const fsPromises = require('fs/promises');

fsPromises.readFile('./file.txt', 'utf8')
    .then(data => console.log(data))
    .catch(err => console.error(err));

// async/await 方式
async function readFile() {
    try {
        const data = await fsPromises.readFile('./file.txt', 'utf8');
        console.log(data);
    } catch (err) {
        console.error(err);
    }
}

// 写入文件（覆盖）
fs.writeFile('./file.txt', 'Hello World', 'utf8', (err) => {
    if (err) throw err;
    console.log('写入成功');
});

// 同步写入
fs.writeFileSync('./file.txt', 'Hello World', 'utf8');

// 追加内容
fs.appendFile('./file.txt', '\n新内容', (err) => {
    if (err) throw err;
    console.log('追加成功');
});

// 流式写入（大文件）
const writeStream = fs.createWriteStream('./file.txt');
writeStream.write('第一行\n');
writeStream.write('第二行\n');
writeStream.end('最后一行\n');

// 检查文件是否存在
fs.existsSync('./file.txt');  // true/false

// 获取文件信息
fs.stat('./file.txt', (err, stats) => {
    console.log(stats.isFile());       // 是否是文件
    console.log(stats.isDirectory());  // 是否是目录
    console.log(stats.size);           // 文件大小（字节）
    console.log(stats.mtime);          // 修改时间
});

// 重命名/移动文件
fs.rename('./old.txt', './new.txt', (err) => {
    if (err) throw err;
    console.log('重命名成功');
});

// 删除文件
fs.unlink('./file.txt', (err) => {
    if (err) throw err;
    console.log('删除成功');
});

// 创建目录
fs.mkdir('./mydir', { recursive: true }, (err) => {
    if (err) throw err;
    console.log('目录创建成功');
});

// 读取目录
fs.readdir('./', (err, files) => {
    if (err) throw err;
    console.log(files);  // 文件名数组
});

// 删除目录（空目录用 rmdir）
fs.rmdir('./mydir', (err) => {
    if (err) throw err;
    console.log('目录删除成功');
});

// 递归删除目录及内容（Node.js 14.14+ 推荐用 fs.rm）
// 注意：fs.rmdir 的 recursive 选项已废弃，旧代码请迁移到 fs.rm
fs.rm('./mydir', { recursive: true, force: true }, (err) => {
    if (err) throw err;
    console.log('目录及内容删除成功');
});

// 读取流（适合大文件）
const readStream = fs.createReadStream('./large-file.txt', {
    encoding: 'utf8',
    highWaterMark: 64 * 1024  // 缓冲区大小 64KB
});

readStream.on('data', (chunk) => {
    console.log('读取到数据块:', chunk.length);
});

readStream.on('end', () => {
    console.log('读取完成');
});

readStream.on('error', (err) => {
    console.error('读取错误:', err);
});

// 管道（pipe）- 复制文件（变量名换一组，避免与上面重复声明）
const srcStream = fs.createReadStream('./source.txt');
const destStream = fs.createWriteStream('./dest.txt');
srcStream.pipe(destStream);

destStream.on('finish', () => {
    console.log('复制完成');
});

const http = require('http');

// 创建服务器
const server = http.createServer((req, res) => {
    // req: 请求对象
    // res: 响应对象

    // 设置响应头
    res.setHeader('Content-Type', 'text/html; charset=utf-8');

    // 发送响应
    res.write('<h1>Hello Node.js</h1>');
    res.end();  // 结束响应
});

// 监听端口
server.listen(3000, () => {
    console.log('服务器运行在 http://localhost:3000/');
});

const server = http.createServer((req, res) => {
    // 请求方法
    console.log(req.method);  // GET, POST, PUT, DELETE...

    // 请求 URL
    console.log(req.url);  // /path?query=value

    // 请求头
    console.log(req.headers);

    // 解析 URL
    const url = require('url');
    const parsedUrl = url.parse(req.url, true);
    console.log(parsedUrl.pathname);  // 路径
    console.log(parsedUrl.query);     // 查询参数对象

    // 根据 URL 路由
    if (req.url === '/' && req.method === 'GET') {
        res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
        res.end('<h1>首页</h1>');
    } else if (req.url === '/api/users' && req.method === 'GET') {
        res.writeHead(200, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({ users: ['张三', '李四'] }));
    } else {
        res.writeHead(404, { 'Content-Type': 'text/plain' });
        res.end('404 Not Found');
    }
});

const server = http.createServer((req, res) => {
    if (req.method === 'POST') {
        let body = '';

        // 接收数据
        req.on('data', (chunk) => {
            body += chunk.toString();
        });

        // 接收完成
        req.on('end', () => {
            console.log('请求体:', body);

            // 解析 JSON
            try {
                const data = JSON.parse(body);
                res.writeHead(200, { 'Content-Type': 'application/json' });
                res.end(JSON.stringify({ success: true, data }));
            } catch (err) {
                res.writeHead(400);
                res.end('Invalid JSON');
            }
        });
    }
});

// 注意：访问 https:// 地址（443 端口）必须用 https 模块，http 模块只能访问 http://
const https = require('https');

// GET 请求
const options = {
    hostname: 'api.github.com',
    port: 443,
    path: '/users/github',
    method: 'GET',
    headers: {
        'User-Agent': 'Node.js'
    }
};

const req = https.request(options, (res) => {
    let data = '';

    res.on('data', (chunk) => {
        data += chunk;
    });

    res.on('end', () => {
        console.log(JSON.parse(data));
    });
});

req.on('error', (err) => {
    console.error(err);
});

req.end();

// 简单的 GET 请求
http.get('http://api.example.com/data', (res) => {
    let data = '';
    res.on('data', chunk => data += chunk);
    res.on('end', () => console.log(data));
});

const EventEmitter = require('events');

// 创建事件发射器
const emitter = new EventEmitter();

// 监听事件
emitter.on('greet', (name) => {
    console.log(`Hello, ${name}!`);
});

// 监听一次性事件
emitter.once('login', (user) => {
    console.log(`${user} 已登录`);
});

// 触发事件
emitter.emit('greet', '张三');  // "Hello, 张三!"
emitter.emit('login', '李四');  // "李四 已登录"
emitter.emit('login', '王五');  // 不会触发（once）

// 移除监听器
const handler = () => console.log('事件处理');
emitter.on('test', handler);
emitter.removeListener('test', handler);

// 移除所有监听器
emitter.removeAllListeners('greet');

// 自定义事件类
class MyEmitter extends EventEmitter {
    constructor() {
        super();
    }

    doSomething() {
        console.log('做一些事情...');
        this.emit('done', { status: 'success' });
    }
}

const myEmitter = new MyEmitter();
myEmitter.on('done', (data) => {
    console.log('完成:', data);
});
myEmitter.doSomething();

const url = require('url');

// 解析 URL（旧 API）
const myURL = url.parse('https://example.com:8080/path?query=value#hash', true);
console.log(myURL.protocol);   // 'https:'
console.log(myURL.host);       // 'example.com:8080'
console.log(myURL.pathname);   // '/path'
console.log(myURL.query);      // { query: 'value' }
console.log(myURL.hash);       // '#hash'

// URL 类（新 API，推荐）
const myURL = new URL('https://example.com:8080/path?query=value#hash');
console.log(myURL.protocol);   // 'https:'
console.log(myURL.hostname);   // 'example.com'
console.log(myURL.port);       // '8080'
console.log(myURL.pathname);   // '/path'
console.log(myURL.search);     // '?query=value'
console.log(myURL.hash);       // '#hash'

// 查询参数
console.log(myURL.searchParams.get('query'));  // 'value'
myURL.searchParams.append('page', '1');
myURL.searchParams.set('query', 'newvalue');
myURL.searchParams.delete('page');

// 格式化 URL（注意：换一个变量名，避免与上面的 myURL 重复声明）
const builtURL = new URL('https://example.com');
builtURL.pathname = '/path';
builtURL.search = '?key=value';
console.log(builtURL.href);  // 'https://example.com/path?key=value'

const querystring = require('querystring');

// 解析查询字符串
const parsed = querystring.parse('name=张三&age=18&hobby=reading&hobby=coding');
console.log(parsed);
// { name: '张三', age: '18', hobby: ['reading', 'coding'] }

// 序列化为查询字符串
const str = querystring.stringify({ name: '张三', age: 18 });
console.log(str);  // 'name=张三&age=18'

// 编码/解码
querystring.escape('hello world');    // 'hello%20world'
querystring.unescape('hello%20world'); // 'hello world'

// 创建 Buffer
const buf1 = Buffer.alloc(10);           // 创建 10 字节的 Buffer（已初始化为 0）
const buf2 = Buffer.allocUnsafe(10);     // 创建 10 字节的 Buffer（未初始化，更快但不安全）
const buf3 = Buffer.from([1, 2, 3]);     // 从数组创建
const buf4 = Buffer.from('Hello', 'utf8'); // 从字符串创建

// Buffer 和字符串互转
const buf = Buffer.from('Hello Node.js', 'utf8');
console.log(buf.toString());           // 'Hello Node.js'
console.log(buf.toString('hex'));      // 十六进制
console.log(buf.toString('base64'));   // base64

// Buffer 操作
const buf = Buffer.from('Hello');
console.log(buf.length);    // 5
console.log(buf[0]);        // 72（'H' 的 ASCII 码）
buf[0] = 104;               // 修改为 'h'
console.log(buf.toString()); // 'hello'

// Buffer 拼接
const buf1 = Buffer.from('Hello ');
const buf2 = Buffer.from('World');
const buf3 = Buffer.concat([buf1, buf2]);
console.log(buf3.toString());  // 'Hello World'

// Buffer 切片
const buf = Buffer.from('Hello World');
const slice = buf.slice(0, 5);
console.log(slice.toString());  // 'Hello'

const fs = require('fs');
const stream = require('stream');

// 可读流
const readStream = fs.createReadStream('./input.txt');

readStream.on('data', (chunk) => {
    console.log('读取数据:', chunk.toString());
});

readStream.on('end', () => {
    console.log('读取完成');
});

readStream.on('error', (err) => {
    console.error('错误:', err);
});

// 可写流
const writeStream = fs.createWriteStream('./output.txt');

writeStream.write('第一行\n');
writeStream.write('第二行\n');
writeStream.end('最后一行\n');

writeStream.on('finish', () => {
    console.log('写入完成');
});

// 管道（pipe）
const inputStream = fs.createReadStream('./input.txt');
const outputStream = fs.createWriteStream('./output.txt');

inputStream.pipe(outputStream);

// 链式管道
const zlib = require('zlib');
fs.createReadStream('input.txt')
    .pipe(zlib.createGzip())
    .pipe(fs.createWriteStream('input.txt.gz'));

// 自定义转换流
const { Transform } = require('stream');

const upperCaseTransform = new Transform({
    transform(chunk, encoding, callback) {
        this.push(chunk.toString().toUpperCase());
        callback();
    }
});

process.stdin
    .pipe(upperCaseTransform)
    .pipe(process.stdout);

// 进程信息
console.log(process.pid);        // 进程 ID
console.log(process.version);    // Node.js 版本
console.log(process.platform);   // 平台（win32, linux, darwin）
console.log(process.arch);       // CPU 架构（x64, arm）
console.log(process.cwd());      // 当前工作目录
console.log(process.execPath);   // Node.js 执行路径

// 命令行参数
// node app.js --port 3000
console.log(process.argv);
// [ '/usr/local/bin/node', '/path/to/app.js', '--port', '3000' ]

// 环境变量
console.log(process.env.NODE_ENV);  // 'development', 'production'
console.log(process.env.PATH);

// 标准输入输出
process.stdout.write('输出内容\n');
process.stderr.write('错误信息\n');

process.stdin.on('data', (data) => {
    console.log('输入:', data.toString());
});

// 退出进程
process.exit(0);  // 0 表示成功，非 0 表示失败

// 监听退出事件
process.on('exit', (code) => {
    console.log(`进程退出，退出码: ${code}`);
});

// 监听未捕获的异常
process.on('uncaughtException', (err) => {
    console.error('未捕获的异常:', err);
    process.exit(1);
});

// 监听未处理的 Promise 拒绝
process.on('unhandledRejection', (reason, promise) => {
    console.error('未处理的 Promise 拒绝:', reason);
});

// 进程信号
process.on('SIGINT', () => {
    console.log('收到 SIGINT 信号（Ctrl+C）');
    process.exit(0);
});

const fs = require('fs');

// 回调函数
fs.readFile('./file.txt', 'utf8', (err, data) => {
    if (err) {
        console.error('读取失败:', err);
        return;
    }
    console.log('文件内容:', data);
});

// 回调地狱（Callback Hell）
fs.readFile('./file1.txt', 'utf8', (err, data1) => {
    if (err) throw err;

    fs.readFile('./file2.txt', 'utf8', (err, data2) => {
        if (err) throw err;

        fs.readFile('./file3.txt', 'utf8', (err, data3) => {
            if (err) throw err;

            console.log(data1, data2, data3);
        });
    });
});

const fs = require('fs').promises;

// 使用 Promise
fs.readFile('./file.txt', 'utf8')
    .then(data => {
        console.log('文件内容:', data);
        return fs.readFile('./file2.txt', 'utf8');
    })
    .then(data => {
        console.log('文件2内容:', data);
    })
    .catch(err => {
        console.error('错误:', err);
    });

// Promise.all - 并发执行
Promise.all([
    fs.readFile('./file1.txt', 'utf8'),
    fs.readFile('./file2.txt', 'utf8'),
    fs.readFile('./file3.txt', 'utf8')
])
    .then(([data1, data2, data3]) => {
        console.log(data1, data2, data3);
    })
    .catch(err => {
        console.error(err);
    });

// 手动创建 Promise
function readFilePromise(path) {
    return new Promise((resolve, reject) => {
        require('fs').readFile(path, 'utf8', (err, data) => {
            if (err) reject(err);
            else resolve(data);
        });
    });
}

readFilePromise('./file.txt')
    .then(data => console.log(data))
    .catch(err => console.error(err));

const fs = require('fs').promises;

// async 函数
async function readFiles() {
    try {
        const data1 = await fs.readFile('./file1.txt', 'utf8');
        const data2 = await fs.readFile('./file2.txt', 'utf8');
        const data3 = await fs.readFile('./file3.txt', 'utf8');

        console.log(data1, data2, data3);
    } catch (err) {
        console.error('错误:', err);
    }
}

readFiles();

// 并发执行
async function readFilesConcurrent() {
    try {
        const [data1, data2, data3] = await Promise.all([
            fs.readFile('./file1.txt', 'utf8'),
            fs.readFile('./file2.txt', 'utf8'),
            fs.readFile('./file3.txt', 'utf8')
        ]);

        console.log(data1, data2, data3);
    } catch (err) {
        console.error('错误:', err);
    }
}

const util = require('util');
const fs = require('fs');

// 将回调函数转为 Promise
const readFilePromise = util.promisify(fs.readFile);

readFilePromise('./file.txt', 'utf8')
    .then(data => console.log(data))
    .catch(err => console.error(err));

// 或使用 async/await
async function readFile() {
    try {
        const data = await readFilePromise('./file.txt', 'utf8');
        console.log(data);
    } catch (err) {
        console.error(err);
    }
}

// 执行顺序示例
console.log('1. 同步代码');

setTimeout(() => {
    console.log('2. setTimeout');
}, 0);

setImmediate(() => {
    console.log('3. setImmediate');
});

process.nextTick(() => {
    console.log('4. nextTick');
});

Promise.resolve().then(() => {
    console.log('5. Promise');
});

console.log('6. 同步代码');

// 输出顺序：
// 1. 同步代码
// 6. 同步代码
// 4. nextTick
// 5. Promise
// 2. setTimeout
// 3. setImmediate

const express = require('express');
const app = express();

// 路由
app.get('/', (req, res) => {
    res.send('Hello Express!');
});

// 启动服务器
app.listen(3000, () => {
    console.log('服务器运行在 http://localhost:3000/');
});

const express = require('express');
const app = express();

// GET 请求
app.get('/', (req, res) => {
    res.send('GET 请求');
});

// POST 请求
app.post('/users', (req, res) => {
    res.send('POST 请求');
});

// PUT 请求
app.put('/users/:id', (req, res) => {
    res.send(`PUT 请求: ${req.params.id}`);
});

// DELETE 请求
app.delete('/users/:id', (req, res) => {
    res.send(`DELETE 请求: ${req.params.id}`);
});

// 所有方法
app.all('/api/*', (req, res) => {
    res.send('匹配所有方法');
});

// 路由参数
app.get('/users/:id', (req, res) => {
    console.log(req.params.id);  // 路径参数
    res.send(`用户 ID: ${req.params.id}`);
});

// 多个路由参数
app.get('/posts/:year/:month', (req, res) => {
    const { year, month } = req.params;
    res.send(`年份: ${year}, 月份: ${month}`);
});

// 查询参数
app.get('/search', (req, res) => {
    console.log(req.query);  // ?keyword=node&page=1
    const { keyword, page } = req.query;
    res.send(`搜索: ${keyword}, 页码: ${page}`);
});